iT邦幫忙

2024 iThome 鐵人賽

DAY 24
0
自我挑戰組

我的Java自學之路:一個轉職者的30篇技術統整系列 第 24

Java IO 與 NIO:檔案操作的基本概念與實踐

  • 分享至 

  • xImage
  •  

引言

在Java程式設計中,檔案操作是一個常見且重要的任務,無論是讀取配置檔案、寫入日誌、處理使用者上傳的檔案,還是管理應用程式的資料存儲,我們都需要進行檔案操作。
Java提供豐富的API來處理檔案,從傳統的java.io包到更現代的java.nio包,為開發者提供多種選擇。

Java檔案操作概述

Java提供多種方式來進行檔案操作,主要分為兩大類:傳統的I/O(java.io包)和新I/O(java.nio包,又稱NIO)。

傳統I/O(java.io)

傳統I/O主要使用以下類別進行檔案操作:

  1. File:用於表示檔案和目錄路徑。
  2. FileInputStream/FileOutputStream:用於讀寫位元資料。
  3. FileReader/FileWriter:用於讀寫字元資料。
  4. BufferedReader/BufferedWriter:為字元輸入/輸出提供緩衝,提高效能。

這些類別提供基本的檔案操作功能,如創建、刪除、重命名檔案,以及讀寫檔案內容。

新I/O(java.nio)

Java NIO(New I/O)在Java 1.4中引入,提供更高效的I/O操作。NIO主要使用以下類別:

  1. Path:表示檔案路徑。
  2. Files:提供大量靜態方法來操作檔案。
  3. FileChannel:用於檔案的讀寫操作。
  4. ByteBuffer:用於緩衝資料。

NIO.2(java.nio.file)

Java 7引入NIO.2,進一步增強檔案操作能力:

  1. 提供更簡單的檔案操作API。
  2. 支援符號連結。
  3. 提供檔案系統的遍歷和監視功能。
  4. 改進檔案屬性的訪問方式。

NIO.2使得檔案操作更加便捷和高效,同時保持與舊版API的兼容性。

使用File類別

File類別是Java I/O中最基本的類別之一,用於表示檔案系統中的檔案和目錄。雖然在Java 7之後,我們有更現代的Path和Files API,但是File類別仍然被廣泛使用,尤其是在處理舊版程式碼時。

創建File物件

創建File物件非常簡單,您可以使用檔案的路徑字串來初始化:

File file = new File("/path/to/file.txt");
File directory = new File("/path/to/directory");

檔案和目錄操作

File類別提供許多方法來操作檔案和目錄:

  1. 創建檔案和目錄:
boolean created = file.createNewFile(); // 創建新檔案
boolean dirCreated = directory.mkdir(); // 創建目錄
boolean dirsCreated = directory.mkdirs(); // 創建多層目錄
  1. 檢查檔案是否存在:
boolean exists = file.exists();
  1. 刪除檔案或目錄:
boolean deleted = file.delete();
  1. 重命名檔案或目錄:
boolean renamed = file.renameTo(new File("/new/path/newname.txt"));
  1. 檢查是檔案還是目錄:
boolean isFile = file.isFile();
boolean isDirectory = file.isDirectory();

獲取檔案資訊

File類別還提供許多方法來獲取檔案的資訊:

long length = file.length(); // 獲取檔案大小(位元組)
long lastModified = file.lastModified(); // 獲取最後修改時間
String name = file.getName(); // 獲取檔案名稱
String path = file.getPath(); // 獲取檔案路徑
String absolutePath = file.getAbsolutePath(); // 獲取絕對路徑

列出目錄內容

您可以使用File類別來列出目錄中的檔案和子目錄:

File[] files = directory.listFiles(); // 獲取目錄中的所有檔案和子目錄
String[] fileNames = directory.list(); // 獲取目錄中的所有檔案和子目錄名稱

注意事項

  • File類別的許多方法在操作失敗時會返回false,而不是拋出異常。這可能會導致錯誤被忽視,所以在使用這些方法時要特別小心。
  • File類別不提供複製檔案的方法,如果需要複製檔案,您需要自己實現或使用Apache Commons IO等第三方庫。
  • 在處理大量檔案或需要更高效能的場景時,考慮使用NIO.2的Path和Files API。

檔案讀寫操作

在Java中,檔案的讀寫操作是最常見的I/O任務之一。Java提供多種方式來進行檔案的讀寫,包括使用傳統的I/O類別和更現代的NIO.2 API。

使用FileInputStream和FileOutputStream

這些類別用於讀寫位元資料:

// 讀取檔案
try (FileInputStream fis = new FileInputStream("input.txt")) {
    int content;
    while ((content = fis.read()) != -1) {
        // 處理讀取的位元資料
        System.out.print((char) content);
    }
} catch (IOException e) {
    e.printStackTrace();
}

// 寫入檔案
try (FileOutputStream fos = new FileOutputStream("output.txt")) {
    String data = "Hello, World!";
    fos.write(data.getBytes());
} catch (IOException e) {
    e.printStackTrace();
}

使用FileReader和FileWriter

這些類別用於讀寫字元資料:

// 讀取檔案
try (FileReader fr = new FileReader("input.txt")) {
    int content;
    while ((content = fr.read()) != -1) {
        System.out.print((char) content);
    }
} catch (IOException e) {
    e.printStackTrace();
}

// 寫入檔案
try (FileWriter fw = new FileWriter("output.txt")) {
    fw.write("你好,世界!");
} catch (IOException e) {
    e.printStackTrace();
}

使用BufferedReader和BufferedWriter

這些類別提供緩衝功能,可以提高讀寫效能:

// 讀取檔案
try (BufferedReader br = new BufferedReader(new FileReader("input.txt"))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

// 寫入檔案
try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
    bw.write("這是第一行");
    bw.newLine();
    bw.write("這是第二行");
} catch (IOException e) {
    e.printStackTrace();
}

使用NIO.2的Files類別

Java 7引入的NIO.2提供更簡潔的檔案讀寫方法:

import java.nio.file.*;

// 讀取檔案
try {
    List<String> lines = Files.readAllLines(Paths.get("input.txt"));
    for (String line : lines) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

// 寫入檔案
try {
    List<String> lines = Arrays.asList("第一行", "第二行", "第三行");
    Files.write(Paths.get("output.txt"), lines);
} catch (IOException e) {
    e.printStackTrace();
}

大檔案處理

對於大檔案,建議使用緩衝串流或NIO的Channel和Buffer:

// 使用FileChannel讀取大檔案
try (FileChannel channel = FileChannel.open(Paths.get("bigfile.dat"), StandardOpenOption.READ)) {
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    while (channel.read(buffer) != -1) {
        buffer.flip();
        // 處理緩衝區中的資料
        buffer.clear();
    }
} catch (IOException e) {
    e.printStackTrace();
}

注意事項

  1. 始終使用try-with-resources語句來確保資源被正確關閉。
  2. 考慮檔案的編碼,特別是在處理非ASCII文字時。
  3. 對於大檔案,使用緩衝串流或NIO來提高效能。
  4. 在多執行緒環境中進行檔案操作時,要注意同步問題。

目錄操作

在Java中,目錄操作是檔案系統管理的重要部分。無論是創建新目錄、列出目錄內容,還是遍歷目錄樹,Java都提供豐富的API來處理這些任務。

使用File類別操作目錄

  1. 創建目錄:
File dir = new File("newDirectory");
boolean created = dir.mkdir(); // 創建單層目錄
boolean createdMultiple = dir.mkdirs(); // 創建多層目錄
  1. 列出目錄內容:
File dir = new File("myDirectory");
String[] fileList = dir.list(); // 獲取檔案名稱列表
File[] files = dir.listFiles(); // 獲取File物件列表
  1. 刪除目錄:
boolean deleted = dir.delete(); // 只能刪除空目錄

使用NIO.2的Files和Path類別

  1. 創建目錄:
Path path = Paths.get("newDirectory");
try {
    Files.createDirectory(path);
    // 或者創建多層目錄
    Files.createDirectories(path);
} catch (IOException e) {
    e.printStackTrace();
}
  1. 列出目錄內容:
try (DirectoryStream<Path> stream = Files.newDirectoryStream(Paths.get("myDirectory"))) {
    for (Path file: stream) {
        System.out.println(file.getFileName());
    }
} catch (IOException e) {
    e.printStackTrace();
}
  1. 遍歷目錄樹:
Path start = Paths.get("rootDirectory");
try {
    Files.walkFileTree(start, new SimpleFileVisitor<Path>() {
        @Override
        public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
            System.out.println(file.toString());
            return FileVisitResult.CONTINUE;
        }
    });
} catch (IOException e) {
    e.printStackTrace();
}
  1. 刪除目錄:
Path path = Paths.get("directoryToDelete");
try {
    Files.delete(path); // 只能刪除空目錄
    // 或者使用遞迴刪除非空目錄
    Files.walkFileTree(path, new SimpleFileVisitor<Path>() {
        @Override
        public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
            Files.delete(file);
            return FileVisitResult.CONTINUE;
        }

        @Override
        public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
            Files.delete(dir);
            return FileVisitResult.CONTINUE;
        }
    });
} catch (IOException e) {
    e.printStackTrace();
}

監視目錄變化

Java NIO.2提供監視目錄變化的功能:

Path dir = Paths.get("watchedDirectory");
try (WatchService watchService = FileSystems.getDefault().newWatchService()) {
    dir.register(watchService, StandardWatchEventKinds.ENTRY_CREATE, 
                               StandardWatchEventKinds.ENTRY_DELETE, 
                               StandardWatchEventKinds.ENTRY_MODIFY);
    while (true) {
        WatchKey key = watchService.take();
        for (WatchEvent<?> event : key.pollEvents()) {
            System.out.println("Event kind: " + event.kind() + ". File affected: " + event.context() + ".");
        }
        key.reset();
    }
} catch (IOException | InterruptedException e) {
    e.printStackTrace();
}

注意事項

  1. 在刪除目錄時要小心,特別是使用遞迴刪除時。
  2. 使用try-with-resources語句來確保資源(如DirectoryStream)被正確關閉。
  3. 在多執行緒環境中操作目錄時,要注意同步問題。
  4. 使用NIO.2的Path和Files API可以提供更好的效能和更豐富的功能。

檔案屬性操作

檔案屬性包括檔案的大小、創建時間、最後修改時間、權限等資訊。Java提供多種方式來獲取和修改這些屬性。

使用File類別

File類別提供一些基本的方法來獲取檔案屬性:

File file = new File("example.txt");

// 獲取檔案大小(位元組)
long size = file.length();

// 獲取最後修改時間
long lastModified = file.lastModified();

// 檢查檔案權限
boolean canRead = file.canRead();
boolean canWrite = file.canWrite();
boolean canExecute = file.canExecute();

// 修改檔案權限
boolean setReadable = file.setReadable(true);
boolean setWritable = file.setWritable(true);
boolean setExecutable = file.setExecutable(true);

使用NIO.2的Files類別

NIO.2提供更豐富的檔案屬性操作方法:

Path path = Paths.get("example.txt");

// 獲取基本屬性
BasicFileAttributes attr = Files.readAttributes(path, BasicFileAttributes.class);
System.out.println("創建時間: " + attr.creationTime());
System.out.println("最後訪問時間: " + attr.lastAccessTime());
System.out.println("最後修改時間: " + attr.lastModifiedTime());
System.out.println("檔案大小: " + attr.size());

// 修改檔案時間屬性
FileTime newLastModifiedTime = FileTime.fromMillis(System.currentTimeMillis());
Files.setLastModifiedTime(path, newLastModifiedTime);

// 獲取和設置POSIX檔案權限(僅在支援POSIX的系統上)
try {
    Set<PosixFilePermission> permissions = Files.getPosixFilePermissions(path);
    permissions.add(PosixFilePermission.OWNER_EXECUTE);
    Files.setPosixFilePermissions(path, permissions);
} catch (UnsupportedOperationException e) {
    System.out.println("This file system does not support POSIX file permissions");
}

// 獲取檔案擁有者
UserPrincipal owner = Files.getOwner(path);
System.out.println("檔案擁有者: " + owner.getName());

// 設置檔案擁有者(需要適當的系統權限)
UserPrincipalLookupService lookupService = FileSystems.getDefault().getUserPrincipalLookupService();
UserPrincipal newOwner = lookupService.lookupPrincipalByName("newowner");
Files.setOwner(path, newOwner);

使用FileStore獲取檔案系統資訊

Path path = Paths.get("example.txt");
FileStore store = Files.getFileStore(path);

System.out.println("檔案系統: " + store.name());
System.out.println("總空間: " + store.getTotalSpace());
System.out.println("可用空間: " + store.getUsableSpace());
System.out.println("未分配空間: " + store.getUnallocatedSpace());

檔案屬性視圖

NIO.2引入檔案屬性視圖的概念,允許訪問特定檔案系統的屬性:

Path path = Paths.get("example.txt");

// 獲取DOS屬性視圖(僅在支援DOS屬性的檔案系統上可用)
try {
    DosFileAttributes dosAttr = Files.readAttributes(path, DosFileAttributes.class);
    System.out.println("是否為隱藏檔案: " + dosAttr.isHidden());
    System.out.println("是否為系統檔案: " + dosAttr.isSystem());
} catch (UnsupportedOperationException e) {
    System.out.println("This file system does not support DOS attributes");
}

注意事項

  1. 某些檔案屬性操作可能需要特殊的系統權限。
  2. 不同的檔案系統可能支援不同的屬性集。在使用特定屬性前,應該先檢查是否支援。
  3. 修改檔案屬性可能會影響其他應用程式對該檔案的訪問,請謹慎操作。
  4. 在處理大量檔案的屬性時,考慮使用批量操作以提高效能。

NIO.2中的檔案操作

Java 7引入的NIO.2(New I/O 2)改進Java的檔案操作能力。NIO.2提供更簡潔、更強大的API,使得檔案和目錄操作變得更加容易和高效。

Path介面

Path是NIO.2中的核心概念,代表檔案系統中的路徑:

Path path = Paths.get("example.txt");
Path absolutePath = path.toAbsolutePath();
Path parentPath = path.getParent();
Path fileName = path.getFileName();

Files類別

Files類別提供大量靜態方法來操作檔案和目錄:

  1. 檔案操作:
// 創建檔案
Files.createFile(Paths.get("newfile.txt"));

// 複製檔案
Files.copy(Paths.get("source.txt"), Paths.get("destination.txt"));

// 移動檔案
Files.move(Paths.get("oldname.txt"), Paths.get("newname.txt"));

// 刪除檔案
Files.delete(Paths.get("tobedeleted.txt"));
  1. 讀寫操作:
// 讀取所有行
List<String> lines = Files.readAllLines(Paths.get("file.txt"));

// 寫入所有行
List<String> linesToWrite = Arrays.asList("Line 1", "Line 2", "Line 3");
Files.write(Paths.get("output.txt"), linesToWrite);

// 使用BufferedReader讀取大檔案
try (BufferedReader reader = Files.newBufferedReader(Paths.get("largefile.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        // 處理每一行
    }
}
  1. 目錄操作:
// 創建目錄
Files.createDirectory(Paths.get("newdir"));

// 創建多層目錄
Files.createDirectories(Paths.get("path/to/newdir"));

// 列出目錄內容
try (DirectoryStream<Path> stream = Files.newDirectoryStream(Paths.get("mydir"))) {
    for (Path entry: stream) {
        System.out.println(entry.getFileName());
    }
}

檔案系統操作

NIO.2提供FileSystem類別來操作檔案系統:

// 獲取默認檔案系統
FileSystem fs = FileSystems.getDefault();

// 獲取所有根目錄
for (Path root : fs.getRootDirectories()) {
    System.out.println(root);
}

// 獲取檔案存儲
for (FileStore store : fs.getFileStores()) {
    System.out.println(store);
}

檔案監視服務

NIO.2引入WatchService,用於監視目錄變化:

WatchService watchService = FileSystems.getDefault().newWatchService();
Path path = Paths.get("watchedDir");
path.register(watchService, StandardWatchEventKinds.ENTRY_CREATE, 
                            StandardWatchEventKinds.ENTRY_DELETE, 
                            StandardWatchEventKinds.ENTRY_MODIFY);

while (true) {
    WatchKey key = watchService.take();
    for (WatchEvent<?> event : key.pollEvents()) {
        System.out.println("Event kind: " + event.kind() + ". File affected: " + event.context() + ".");
    }
    key.reset();
}

SeekableByteChannel

NIO.2提供SeekableByteChannel介面,允許在檔案中隨機訪問:

try (SeekableByteChannel channel = Files.newByteChannel(Paths.get("file.txt"))) {
    ByteBuffer buffer = ByteBuffer.allocate(10);
    channel.position(100); // 移動到檔案的第100個位元組
    channel.read(buffer);
    buffer.flip();
    // 處理讀取的資料
}

優點和注意事項

  1. NIO.2提供更一致和更強大的檔案操作API。
  2. Path介面比File類別更靈活,支援不同的檔案系統。
  3. Files類別的方法通常比傳統I/O更高效。
  4. NIO.2支援符號連結和檔案屬性的高級操作。
  5. 使用try-with-resources語句來自動關閉資源。
  6. 注意處理可能拋出的IOException。

NIO.2簡化Java中的檔案操作,提供更現代、更強大的API。
對於新的專案,建議優先考慮使用NIO.2來進行檔案和目錄操作。

實踐和注意事項

在進行Java檔案操作時,遵循一些最佳實踐可以幫助您寫出更安全、更高效的程式碼。以下是一些重要的建議和注意事項:

1. 使用try-with-resources語句

始終使用try-with-resources語句來自動關閉資源,這可以防止資源洩漏:

try (BufferedReader reader = Files.newBufferedReader(Paths.get("file.txt"))) {
    // 使用reader
} catch (IOException e) {
    e.printStackTrace();
}

2. 正確處理異常

不要忽視或吞掉異常。適當地處理IOException和其他可能的異常:

try {
    Files.move(source, target);
} catch (IOException e) {
    System.err.println("無法移動檔案: " + e.getMessage());
    // 根據需要進行錯誤處理或重試
}

3. 使用NIO.2 API

對於新的專案,優先考慮使用NIO.2(java.nio.file包)而不是舊的java.io.File類別。NIO.2提供更強大和一致的API。

4. 考慮檔案系統的差異

記住不同的操作系統可能有不同的檔案系統行為。例如,檔案路徑分隔符、檔案名稱大小寫敏感性等:

String separator = File.separator; // 使用系統特定的路徑分隔符

5. 檢查檔案存在性和權限

在操作檔案之前,檢查檔案是否存在以及是否有適當的權限:

Path path = Paths.get("example.txt");
if (Files.exists(path) && Files.isReadable(path)) {
    // 進行檔案操作
}

6. 使用緩衝進行大檔案操作

對於大檔案的讀寫操作,使用緩衝串流或NIO的Channel和Buffer來提高效能:

try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("largefile.dat"))) {
    // 使用緩衝串流讀取
}

7. 安全地刪除檔案

在刪除檔案或目錄時要小心,特別是在遞迴刪除目錄時:

Files.walkFileTree(Paths.get("directory"), new SimpleFileVisitor<Path>() {
    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
        Files.delete(file);
        return FileVisitResult.CONTINUE;
    }

    @Override
    public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
        Files.delete(dir);
        return FileVisitResult.CONTINUE;
    }
});

8. 使用相對路徑

盡可能使用相對路徑而不是絕對路徑,這可以提高程式的可移植性:

Path relativePath = Paths.get("resources", "config.properties");

9. 注意檔案鎖定

在多執行緒或多行程環境中,使用檔案鎖定來防止資料損壞:

try (FileChannel channel = FileChannel.open(path, StandardOpenOption.WRITE)) {
    FileLock lock = channel.lock();
    try {
        // 執行需要鎖定的操作
    } finally {
        lock.release();
    }
}

10. 定期備份重要資料

在進行關鍵的檔案操作之前,考慮備份重要資料:

Files.copy(source, backup, StandardCopyOption.REPLACE_EXISTING);

11. 使用適當的字元編碼

在讀寫文字檔案時,明確指定字元編碼以避免編碼問題:

Charset utf8 = StandardCharsets.UTF_8;
List<String> lines = Files.readAllLines(path, utf8);

本篇文章同步刊載: JYI.TW
筆者個人的網站: JUNYI


上一篇
Java IO 串流:類型、應用及最佳實踐
下一篇
Java NIO 原理:Buffer 與 Channel 的運作機制
系列文
我的Java自學之路:一個轉職者的30篇技術統整30
圖片
  直播研討會
圖片
{{ item.channelVendor }} {{ item.webinarstarted }} |
{{ formatDate(item.duration) }}
直播中

尚未有邦友留言

立即登入留言